﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Windows;
using CalculoPreciosUnitarios.BaseDeDatos.cotizararticuloDataSetTableAdapters;
using CalculoPreciosUnitarios.Logica.GestorObject.Rubro;
using MySql.Data.MySqlClient;

namespace CalculoPreciosUnitarios.Logica.GestorBaseDeDatos.Rubro
{
    public class RubroDB
    {

        private IFormatProvider argento = new System.Globalization.CultureInfo("es-AR");

        /**
         * Rubros
         **/

        #region Rubros

        #region CRUD Rubros

        /// <summary>
        /// Agrega un Rubro
        /// </summary>
        /// <param name="nuevoRubro"></param>
        /// <param name="confirmacion"> Utilizado para cuando se agrega por Excel</param>
        /// <param name="forzado"> Utilizado para el caso de utilizacion de Tecla F2, en la ventana Administracion de Rubros</param>
        /// <returns> 1 Si no hubo problemas en agregado a la Base de Datos; 0 en caso de que halla un error</returns>

        public int AddRubro(RubroCS nuevoRubro, bool confirmacion, bool forzado)
        {
            int resultadoConsulta = 0;

            RubroCS auxRubro = new RubroCS();
            auxRubro.IdRubro = nuevoRubro.IdRubro;

            rubroTableAdapter rubroTA = new rubroTableAdapter();
            
            rubroTA.Connection.Open();

            if (forzado)
            {
                auxRubro = ObtenerRubroPorCodigoExacto(auxRubro);
            }
            else
            {
                auxRubro = ObtenerRubroPorCodigo(auxRubro);
            }

            
            
            try
            {
                string codigo = RellenarCodigo(nuevoRubro.IdRubro.ToUpper());
                string descripcion = nuevoRubro.Descripcion.ToUpper();

                if (auxRubro.IdRubro.Equals(""))
                {
                    resultadoConsulta = rubroTA.Insert(codigo, descripcion);

                    if (resultadoConsulta == 1 && confirmacion)
                        MessageBox.Show("Rubro " + descripcion + " con Codigo " + codigo + " Agregado!");
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Error AddRubro - RubroDB " + e.Message, "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultadoConsulta;
        }

        /// <summary>
        /// Devuelve los rubros encontrado con el codigo administrado
        /// </summary>
        /// <param name="rubro"> Contiene el codigo utilizado</param>
        /// <returns> Una Lista de Rubros que coinciden con el codigo proporcionado </returns>
        public List<RubroCS> ObtenerRubrosPorCodigo(RubroCS rubro)
        {
            List<RubroCS> resultado = new List<RubroCS>();

            rubroTableAdapter rubroTA = new rubroTableAdapter();

            rubroTA.Connection.Open();

            try
            {
                DataTable tablaRubros = rubroTA.GetDataByObtenerRubroPorCodigo("%" + rubro.IdRubro.ToUpper() + "%");

                if (tablaRubros.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaRubros.Rows)
                    {
                        RubroCS _rubro = new RubroCS();
                        _rubro.IdRubro = item["id_rubro"].ToString();
                        _rubro.Descripcion = item["descripcion"].ToString();
                        _rubro.CantidadSubRubros = ObtenerSubRubrosPorCodigoDeRubro(_rubro).Count;

                        resultado.Add(_rubro);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerRubroPorCodigo(string idRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Devuelve los rubros encontrado con la descripcion administrada
        /// </summary>
        /// <param name="rubro"> Contiene la descripcion utilizada</param>
        /// <returns> Una Lista de Rubros que coinciden con la descripcion proporcionada </returns>
        public List<RubroCS> ObtenerRubrosPorDescripcion(RubroCS rubro)
        {
            List<RubroCS> resultado = new List<RubroCS>();

            rubroTableAdapter rubroTA = new rubroTableAdapter();

            rubroTA.Connection.Open();

            try
            {
                DataTable tablaRubros = rubroTA.GetDataByGetRubroPorDescripcion("%" + rubro.Descripcion.ToUpper() + "%");

                if (tablaRubros.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaRubros.Rows)
                    {
                        RubroCS _rubro = new RubroCS();
                        _rubro.IdRubro = item["id_rubro"].ToString();
                        _rubro.Descripcion = item["descripcion"].ToString();
                        _rubro.CantidadSubRubros = ObtenerSubRubrosPorCodigoDeRubro(_rubro).Count;

                        resultado.Add(_rubro);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerRubroPorCodigo(string idRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Busca un rubro por su codigo
        /// </summary>
        /// <param name="rubro"> Un Rubro auxiliar que contiene el codigo del Rubro buscado</param>
        /// <returns>El Rubro Buscado o vacio si no encuentra</returns>
        public RubroCS ObtenerRubroPorCodigo(RubroCS rubro)
        {
            RubroCS resultadoRubro = new RubroCS();
            List<RubroCS> resultados = ObtenerRubrosPorCodigo(rubro);

            if (resultados.Count > 0)
            {
                resultadoRubro = resultados[0];
            }

            return resultadoRubro;
        }

        /// <summary>
        /// Busca un rubro por su codigo EXACTO
        /// </summary>
        /// <param name="rubro"> Un Rubro auxiliar que contiene el codigo EXACTO del Rubro buscado</param>
        /// <returns>El Rubro Buscado o vacio si no encuentra</returns>
        public RubroCS ObtenerRubroPorCodigoExacto(RubroCS rubro)
        {
            RubroCS resultado = new RubroCS();

            rubroTableAdapter rubroTA = new rubroTableAdapter();

            rubroTA.Connection.Open();

            try
            {
                DataTable tablaRubros = rubroTA.GetDataByObtenerRubroPorCodigo(rubro.IdRubro.ToUpper());

                if (tablaRubros.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaRubros.Rows)
                    {
                        resultado.IdRubro = item["id_rubro"].ToString();
                        resultado.Descripcion = item["descripcion"].ToString();
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerRubroPorCodigoExacto(auxRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Devuelve el rubro encontrado con la descripcion administrada
        /// </summary>
        /// <param name="rubro"> Contiene la descripcion utilizada</param>
        /// <returns> El rubro que coincide con la descripcion proporcionada </returns>
        public RubroCS ObtenerRubroPorDescripcion(RubroCS rubro)
        {

            RubroCS resultadoRubro = new RubroCS();
            List<RubroCS> resultados = ObtenerRubrosPorDescripcion(rubro);

            if (resultados.Count > 0)
            {
                resultadoRubro = resultados[0];
            }

            return resultadoRubro;
        }

        /// <summary>
        /// Actualiza la descripcion o el codigo del Rubro proporcionado
        /// </summary>
        /// <param name="codigo">Codigo de Rubro a Actualizar</param>
        /// <param name="descripcion">Descripcion con la que se reemplaza el rubro actualizado</param>
        /// <param name="nuevoCodigoRubro">Nuevo codigo para el rubro a actualizar</param>
        /// <returns>1 Si todo correcto; 0 en caso de error</returns>
        private int UpdateRubro(string codigo, string descripcion, string nuevoCodigoRubro)
        {
            rubroTableAdapter rubroTA = new rubroTableAdapter();

            int resultadoConsulta = 0;

            rubroTA.Connection.Open();

            try
            {
                nuevoCodigoRubro = RellenarCodigo(nuevoCodigoRubro);
                
                resultadoConsulta = rubroTA.UpdateRubro(nuevoCodigoRubro.ToUpper(), descripcion.ToUpper(), codigo.ToUpper());

                if (resultadoConsulta == 1)
                    MessageBox.Show("Rubro " + descripcion + " con codigo " + nuevoCodigoRubro + " MODIFICADO!");

            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods UpdateRubro(string codigo, string descripcion)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultadoConsulta;
        }

        /// <summary>
        /// Elimina el Rubro proporcionado
        /// </summary>
        /// <param name="codigo">Codigo del rubro a eliminar</param>
        /// <returns>1 si todo correcto; 0 si hay algun error</returns>
        private int EliminarRubro(string codigo)
        {
            rubroTableAdapter rubroTA = new rubroTableAdapter();

            int resultadoConsulta = 0;

            rubroTA.Connection.Open();
            
            try
            {
                resultadoConsulta = EliminarSubRubrosDelRubro(codigo);
                if (resultadoConsulta == 1)
                {
                    rubroTA.DeleteRubro(codigo.ToUpper());
                }
                
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods EliminarRubro(string codigo)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultadoConsulta;
        }

        #endregion

        /// <summary>
        /// Obtiene todos los rubros de la base de Datos
        /// </summary>
        /// <returns>Los Rubros de la base de datos</returns>
        public List<RubroCS> ObtenerRubros()
        {

            List<RubroCS> resultados = new List<RubroCS>();
            resultados.Clear();

            rubroTableAdapter rubroTA = new rubroTableAdapter();

            rubroTA.Connection.Open();
            
            try
            {
                DataTable tablaRubros = rubroTA.GetDataByGetRubros();

                if (tablaRubros.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaRubros.Rows)
                    {
                        RubroCS rubro = new RubroCS();

                        rubro.IdRubro = item["id_rubro"].ToString();
                        rubro.Descripcion = item["descripcion"].ToString();

                        resultados.Add(rubro);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerRubros()", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                rubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// Actualiza el rubro proporcionado
        /// </summary>
        /// <param name="rubro">Rubro a actualizar</param>
        /// <param name="nuevo">Rubro con los datos actualizados</param>
        /// <returns>1 exitoso; 0 error</returns>
        public int UpdateRubro(RubroCS rubro, RubroCS nuevo)
        {
            return UpdateRubro(rubro.IdRubro, rubro.Descripcion, nuevo.IdRubro);
        }

        /// <summary>
        /// Elimina el Rubro proporcionado
        /// </summary>
        /// <param name="rubro">Rubro a eliminar</param>
        /// <returns>1 exitoso; 0 error</returns>
        public int EliminarRubro(RubroCS rubro)
        {
            return EliminarRubro(rubro.IdRubro);
        }

        /// <summary>
        /// Cambia el codigo del rubro proporcionado en el parametro <b>viejo</b>, por el nuevo codigo en el parametro <b>nuevo</b>
        /// </summary>
        /// <param name="viejo">Rubro con codigo que se debe cambiar</param>
        /// <param name="nuevo">Rubro con el nuevo codigo que se debe modificar</param>
        /// <returns>1 exitoso; 0 error</returns>
        public int CambiarCodigoRubro(RubroCS viejo, RubroCS nuevo)
        {
            RubroCS rubro = ObtenerRubroPorCodigoExacto(viejo);
            return UpdateRubro(rubro, nuevo);
        }

        /// <summary>
        /// Carga masivamente los rubros proporcionado en la lista pasada como parametro
        /// </summary>
        /// <param name="rubros">Rubros a cargar</param>
        /// <returns>1 carga exitosa; 0 carga fallida</returns>
        public int CargarRubros(List<RubroCS> rubros)
        {
            int resultadoConsulta = 1;

            if (rubros.Count > 0)
            {
                foreach (RubroCS item in rubros)
                {
                    resultadoConsulta *= AddRubro(item, false, false);
                }
            }

            return resultadoConsulta;
        }

        #endregion

        /**
         * Sub Rubros
         **/
        #region SubRubros

        #region CRUD SubRubros

        /// <summary>
        /// Agrega un nuevo Sub Rubro
        /// </summary>
        /// <param name="subRubro">El Sub Rubro a agregar</param>
        /// <returns>1 exitoso; 0 fallo</returns>
        public int AddSubRubro(SubRubroCS subRubro)
        {
            int resultadoConsulta = 0;
            RubroCS rubro = new RubroCS();
            rubro.IdRubro = subRubro.IdRubro;
            rubro = ObtenerRubroPorCodigoExacto(rubro);

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();

            try
            {
                string codigoRubro = RellenarCodigo(subRubro.IdRubro.ToUpper());
                string codigoSubRubro = RellenarCodigo(subRubro.IdSubRubro.ToUpper());
                string descripcion = subRubro.Descripcion.ToUpper();
                decimal precio = subRubro.Precio;

                if (!rubro.IdRubro.Equals(""))
                {
                    resultadoConsulta = subRubroTA.InsertSubRubro(codigoRubro, codigoSubRubro, descripcion, precio);
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Error AddSubRubro - Clase RubroDB " + e.Message, "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultadoConsulta;
        }

        /// <summary>
        /// Obtiene el Sub Rubro por el codigo proporcionado
        /// </summary>
        /// <param name="subRubro">Sub Rubro que contiene el codigo buscado</param>
        /// <returns>El Sub Rubro buscado o un Sub Rubro de codigo vacio si no lo encuentra</returns>
        public SubRubroCS ObtenerSubRubroPorCodigo(SubRubroCS subRubro)
        {
            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            SubRubroCS resultado = new SubRubroCS();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetDataByObtenerSubRubroPorCodigo("%" + subRubro.IdRubro + "%", "%" + subRubro.IdSubRubro + "%");

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubroPorCodigo(SubRubroCS subRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Devuelve los Sub Rubros que coinciden con la descripcion proporcionada
        /// </summary>
        /// <param name="subRubro">Sub rubro que contiene la descripcion buscada</param>
        /// <returns>Una lista de Sub rubros con coindiden con la descripcion proporcionada, en caso de no encontrar ninguna coindidencia
        /// devuelve una lista vacia</returns>
        public List<SubRubroCS> ObtenerSubRubrosPorDescripcion(SubRubroCS subRubro)
        {
            List<SubRubroCS> resultado = new List<SubRubroCS>();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();

            try
            {
                DataTable tabla = subRubroTA.GetDataByObtenerSubRubroPorDescripcion("%" + subRubro.Descripcion + "%");

                if (tabla.Rows.Count > 0)
                {
                    foreach (DataRow item in tabla.Rows)
                    {
                        SubRubroCS _subRubro = new SubRubroCS();
                        _subRubro.IdRubro = item["id_rubro"].ToString().ToUpper();
                        _subRubro.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        _subRubro.Descripcion = item["descripcion"].ToString().ToUpper();
                        _subRubro.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultado.Add(_subRubro);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show("Error -- Metodo ObtenerSubRubrosPorDescripcion(subRubro) -- Clase RubroDB " + e.Message);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultado;
        }

        /// <summary>
        /// Actualiza el Sub Rubro proporcionado 
        /// </summary>
        /// <param name="codigoRubro">Codigo de Rubro del Sub Rubro a actualizar</param>
        /// <param name="codigoSubRubro">Codigo del Sub Rubro a actualizar</param>
        /// <param name="descripcion">Nueva descripcion para el Sub Rubro </param>
        /// <param name="precio">Nuevo Precio para el Sub Rubro</param>
        /// <param name="nuevoCodigo">Nuevo Codigo para el Sub Rubro</param>
        /// <returns>1 exitoso; 0 error</returns>
        private int UpdateSubRubro(string codigoRubro, string codigoSubRubro, string descripcion, decimal precio, string nuevoCodigo)
        {
            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            int resultadoConsulta = 0;

            subRubroTA.Connection.Open();
            
            try
            {
                nuevoCodigo = RellenarCodigo(nuevoCodigo);
                resultadoConsulta = subRubroTA.UpdateSubRubro(nuevoCodigo,descripcion,precio,codigoRubro,codigoSubRubro);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods UpdateSubRubro(codigoRubro,codigoSubRubro,descripcion,precio)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultadoConsulta;
        }

        /// <summary>
        /// Elimina el Sub rubro proporcionado
        /// </summary>
        /// <param name="codigoRubro">Codigo de Rubro del Sub Rubro a eliminar</param>
        /// <param name="codigoSubRubro">Codigo de Sub Rubro a eliminar</param>
        /// <returns>1 exito; 0 error</returns>
        private int EliminarSubRubro(string codigoRubro, string codigoSubRubro)
        {
            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            int resultadoConsulta = 0;

            subRubroTA.Connection.Open();

            try
            {
                resultadoConsulta = subRubroTA.DeleteSubRubro(codigoRubro, codigoSubRubro);
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods EliminarSubRubro(codigoRubro, codigoSubRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            } 
            
            return resultadoConsulta;
        }
        
        #endregion
 
        /// <summary>
        /// Obtiene Sub Rubros por el Rubro proporcionado
        /// </summary>
        /// <param name="rubro">Rubro que contiene el codigo buscado</param>
        /// <returns>Una lista con todos los Sub Rubros del Rubro proporcionado o vacia si no hay coincidencia</returns>
        public List<SubRubroCS> ObtenerSubRubrosPorCodigoDeRubro(RubroCS rubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetDataBySubRubrosPorCodigoDeRubro(rubro.IdRubro);

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosPorCodigoDeRubro(string codigoRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// Obtiene todos los sub rubros que coinciden con el codigo pasado como parametro
        /// </summary>
        /// <param name="subRubro">El Sub rubro con el codigo buscado</param>
        /// <returns>Una lista con las coincidencias o vacio en caso de no encontrar nada</returns>
        /// 
        private List<SubRubroCS> ObtenerSubRubrosPorSoloCodigoDeSubRubro(SubRubroCS subRubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();

            string codigo = RellenarCodigo(subRubro.IdSubRubro);

            try
            {
                DataTable tablaResultados = subRubroTA.GetDataByObtenerSubRubrosPorCodigoDeSubRubro("%" + codigo + "%");

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosPorSoloCodigoDeSubRubro(SubRubroCS subRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        public List<SubRubroCS> ObtenerSubRubrosPorCodigoDeRubro_dos(SubRubroCS rubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetDataBySubRubrosPorCodigoDeRubro(rubro.IdRubro);

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosPorCodigoDeRubro(string codigoRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// Actualizar el Sub Rubro proporcionado
        /// </summary>
        /// <param name="viejoSubRubro">el sub rubro a actualizar</param>
        /// <param name="nuevoSubRubro">el nuevo Sub Rubro actualizado</param>
        /// <returns>1 exito; 0 error</returns>
        public int UpdateSubRubro(SubRubroCS viejoSubRubro, SubRubroCS nuevoSubRubro)
        {
            return UpdateSubRubro(viejoSubRubro.IdRubro, viejoSubRubro.IdSubRubro, viejoSubRubro.Descripcion, viejoSubRubro.Precio, nuevoSubRubro.IdSubRubro);
        }

        /// <summary>
        /// Elimina el Sub Rubro proporcionado
        /// </summary>
        /// <param name="subRubro">El Sub Rubro a eliminar</param>
        /// <returns>1 exito; 0 eror</returns>
        public int EliminarSubRubro(SubRubroCS subRubro)
        {
            return EliminarSubRubro(subRubro.IdRubro, subRubro.IdSubRubro);
        }

        /// <summary>
        /// Elimina los Sub Rubros del Rubro proporcionado
        /// </summary>
        /// <param name="codigoRubro">El codigo del Rubro, para saber que Sub Rubros Eliminar</param>
        /// <returns>1 exitoso; 0 error</returns>
        private int EliminarSubRubrosDelRubro(string codigoRubro)
        {
            RubroCS auxiliarRubro = new RubroCS();
            auxiliarRubro.IdRubro = codigoRubro;
            RubroCS auxRubro = ObtenerRubroPorCodigoExacto(auxiliarRubro);

            List<SubRubroCS> subRubrosDelRubro = ObtenerSubRubrosPorCodigoDeRubro(auxRubro);

            int resultadoConsulta = 1;

            foreach (SubRubroCS item in subRubrosDelRubro)
            {
                resultadoConsulta *= EliminarSubRubro(item);
            }

            return resultadoConsulta;
        }

        /// <summary>
        /// Cambia el codigo del Sub Rubro por el nuevo proporcionado
        /// </summary>
        /// <param name="viejoSubRubro">Sub Rubro a cambiar</param>
        /// <param name="nuevoSubRubro">Nuevo Codigo</param>
        public void CambiarCodigoSubRubro(SubRubroCS viejo, SubRubroCS nuevo)
        {
            SubRubroCS auxiliarSubRubro = new SubRubroCS();
            auxiliarSubRubro.IdRubro = viejo.IdRubro;
            auxiliarSubRubro.IdSubRubro = viejo.IdSubRubro;

            SubRubroCS subRubro = ObtenerSubRubroPorCodigo(auxiliarSubRubro);
            UpdateSubRubro(subRubro, nuevo);
        }
        
        /// <summary>
        /// Carga todos los Sub Rubros de la lista proporcionada
        /// </summary>
        /// <param name="subRubros">La lista de Sub Rubros a cargar</param>
        /// <returns>1 exitoso; 0 error</returns>
        public int CargarSubRubros(List<SubRubroCS> subRubros)
        {
            int resultadoConsulta = 1;

            if (subRubros.Count > 0)
            {
                foreach (SubRubroCS item in subRubros)
                {
                    resultadoConsulta *= AddSubRubro(item);
                }
            }

            return resultadoConsulta;
        }


        #region German
        /// <summary>
        /// devuelve todos los subrubros
        /// </summary>
        /// <returns></returns>
        public List<SubRubroCS> ObtenerSubRubros()
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetData();

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();                        
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubros()", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// devuelve todos los subrubros por descripcion
        /// </summary>
        /// <returns></returns>
        public List<SubRubroCS> ObtenerSubRubrosXdescripcion(SubRubroCS _subRubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetDataByXdescripcion("%" + _subRubro.Descripcion +"%");

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosXdescripcion(string codigoRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// devuelve todos los subrubros por codigo
        /// </summary>
        /// <returns></returns>
        public List<SubRubroCS> ObtenerSubRubrosXCodigoR_S(SubRubroCS _misubRubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                DataTable tablaResultados = subRubroTA.GetDataByObtenerSubRubroPorCodigo(_misubRubro.IdRubro, _misubRubro.IdSubRubro);

                if (tablaResultados.Rows.Count > 0)
                {
                    foreach (DataRow item in tablaResultados.Rows)
                    {
                        SubRubroCS resultado = new SubRubroCS();

                        resultado.IdRubro = item["id_rubro"].ToString().ToUpper();
                        resultado.IdSubRubro = item["id_subrubro"].ToString().ToUpper();
                        resultado.Descripcion = item["descripcion"].ToString().ToUpper();
                        resultado.Precio = Convert.ToDecimal(item["precio_subRubro"], argento);

                        resultados.Add(resultado);
                    }
                }
                else
                {
                    resultados.Clear();
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosXCodigoR_S(SubRubroCS _misubRubro)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        /// <summary>
        /// devuelve todos el/los subrubros
        /// </summary>
        /// <returns></returns>
        public List<SubRubroCS> ObtenerSR(SubRubroCS _misubRubro)
        {
            List<SubRubroCS> resultados = new List<SubRubroCS>();
            resultados.Clear();

            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();

            subRubroTA.Connection.Open();
            
            try
            {
                if ((string.IsNullOrEmpty(_misubRubro.IdRubro) || (_misubRubro.IdRubro.Equals("0000"))) && !(string.IsNullOrEmpty(_misubRubro.IdSubRubro)))
                {
                    resultados = ObtenerSubRubrosPorSoloCodigoDeSubRubro(_misubRubro);
                }
                else if (!(string.IsNullOrEmpty(_misubRubro.IdRubro)) && !(string.IsNullOrEmpty(_misubRubro.IdSubRubro)))
                {
                    resultados = ObtenerSubRubrosXCodigoR_S(_misubRubro);
                }
                else
                {
                    if (!(string.IsNullOrEmpty(_misubRubro.IdRubro)) && (string.IsNullOrEmpty(_misubRubro.IdSubRubro)))
                    {
                        resultados = ObtenerSubRubrosPorCodigoDeRubro_dos(_misubRubro);
                    }
                }

            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods ObtenerSubRubrosXCodigoR_S", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }

            return resultados;
        }

        //
        // actualzia tabla subRubro por idRubro y idSubRubro y solo el campo precio se modifica.
        //
        public void Update_SubRubro_Solo_Precio(SubRubroCS _SubRubro)
        {
            subrubroTableAdapter subRubroTA = new subrubroTableAdapter();
            int iResult = 0;

            subRubroTA.Connection.Open();
            MySqlTransaction mitransaccion = subRubroTA.Connection.BeginTransaction();
            try
            {
                iResult = subRubroTA.UpdateSoloPrecio(_SubRubro.Precio, _SubRubro.IdRubro, _SubRubro.IdSubRubro);
                if (iResult == 1)
                {
                    mitransaccion.Commit();
                    MessageBox.Show("Operacion de inserción exitosa", "Información", MessageBoxButton.OK);
                }
            }
            catch (Exception e)
            {
                mitransaccion.Rollback();
                MessageBox.Show(e.Message + " Error -- Class RubroDB -- Methods UpdateSubRubro(codigoRubro,codigoSubRubro,descripcion,precio)", "Cuidado", MessageBoxButton.OK);
            }
            finally
            {
                subRubroTA.Connection.Close();
            }
        }

        #endregion German

        #region Auxiliar Methods

        private string RellenarCodigo(string codigo)
        {
            return codigo.PadLeft(4, '0');
        }

        #endregion

        #endregion
    }
}